home *** CD-ROM | disk | FTP | other *** search
/ Shareware Grab Bag / Shareware Grab Bag.iso / 090 / revgrep.cq / revgrep.c
Encoding:
Text File  |  1986-03-11  |  19.8 KB  |  759 lines
  1.  
  2. Relay-Version: version B 2.10.2 9/5/84; site philabs.UUCP
  3. Path: philabs!cmcl2!harvard!talcott!panda!genrad!decvax!bellcore!ulysses!mhuxr!mhuxn!ihnp4!wucs!nz
  4. From: nz@wucs.UUCP (Neal Ziring)
  5. Newsgroups: net.sources
  6. Subject: reverse grep (now sysV compatible!)
  7. Message-ID: <1458@wucs.UUCP>
  8. Date: 25 Feb 86 17:41:34 GMT
  9. Date-Received: 27 Feb 86 05:07:30 GMT
  10. Organization: Washington U. Engineering Computer Lab
  11. Lines: 742
  12. Keywords: grep search filter tail source
  13.  
  14. <<I tried sending this to mod.sources, but it couldn't get there>>
  15.  
  16. Grep is one of the most useful filters around, but sometimes you
  17. are more interested in what is going on near the end of a file than
  18. you are in what is going on at the front.  Grep, and most other filters,
  19. look at the front of a file before proceeding to its end.  Log files
  20. are often most interesting near the end.
  21.  
  22. Revgrep behaves very much like grep, except that it reads lines of a
  23. file in reverse order -- end towards beginning.  Also, revgrep subsumes
  24. the functionality of tail, without tail's length restrictions.
  25.  
  26. I hope Berkeley and SystemV users find revgrep as useful as I do.
  27.  
  28. ...nz (Neal Ziring @ Washington University Engineering Computer Lab)
  29.  
  30. --------------------
  31. #! /bin/sh
  32. # This is a shell archive, meaning:
  33. # 1. Remove everything above the #! /bin/sh line.
  34. # 2. Save the resulting text in a file.
  35. # 3. Execute the file with /bin/sh (not csh) to create the files:
  36. #    README
  37. #    Makefile
  38. #    revgrep.1
  39. #    revgrep.c
  40. # This archive created: Mon Feb 24 09:17:31 1986
  41. # By:    Neal Ziring (Washington U. Engineering Computer Lab)
  42. export PATH; PATH=/bin:$PATH
  43. if test -f 'README'
  44. then
  45.     echo shar: will not over-write existing file "'README'"
  46. else
  47. cat << \SHAR_EOF > 'README'
  48. The Makefile for revgrep is designed for Berkeley Unix, to change it for
  49. AT&T system V, change the CFLAGS and LIBES variables as shown below.
  50.  
  51. CFLAGS= -DUSG
  52. LIBES= -lPW
  53.  
  54. Send any complaints or suggestions about revgrep to nz@wucs.UUCP .
  55.  
  56. SHAR_EOF
  57. fi # end of overwriting check
  58. if test -f 'Makefile'
  59. then
  60.     echo shar: will not over-write existing file "'Makefile'"
  61. else
  62. cat << \SHAR_EOF > 'Makefile'
  63. #
  64. # revgrep: search files for a pattern, backwards
  65. #
  66. #     Revgrep used to be composed of three source files, 
  67. #   revgrep.c, revio.c, and revgrep.h.  Since none of the
  68. #   three were particularly big, they were combined into 
  69. #   one source file, revgrep.c.
  70. #
  71. SRCS= revgrep.c
  72. OBJS= revgrep.o 
  73. CFLAGS= -O
  74. LIBES=
  75.  
  76. DESTDIR= /usr/local/bin
  77.  
  78. all: revgrep
  79.  
  80. install: revgrep
  81.     install -s -m 755 revgrep ${DESTDIR}
  82.  
  83. revgrep: ${OBJS}
  84.     cc ${CFLAGS} -o revgrep ${OBJS} ${LIBES}
  85.  
  86. clean: 
  87.     rm -f revgrep.o a.out
  88. SHAR_EOF
  89. fi # end of overwriting check
  90. if test -f 'revgrep.1'
  91. then
  92.     echo shar: will not over-write existing file "'revgrep.1'"
  93. else
  94. cat << \SHAR_EOF > 'revgrep.1'
  95. .TH REVGREP 1 "7 September 1985"
  96. .UC 4
  97. .SH NAME
  98. revgrep \- search a file for a pattern backwards, provide tails
  99. .SH SYNOPSIS
  100. .B revgrep
  101. [ option ] ...
  102. expression [ file ] ...
  103. .SH DESCRIPTION
  104. .I Revgrep
  105. is a variant of the 
  106. .I grep
  107. family.
  108. The named
  109. .I files
  110. (standard input default)
  111. are searched from the end towards the beginning
  112. for occurences of the specified pattern.
  113. The patterns recognized are limited regular expressions
  114. of the type described the manual entry for
  115. .IR ed (1).
  116. The library routine
  117. .IR regex (3)
  118. is used to do pattern matching.
  119. .PP
  120. .I Revgrep 
  121. can also be used to print a trailing portion of a file, either based on 
  122. the occurence of a pattern, or on a number of lines.  In this function it
  123. is subsumed by 
  124. .IR sed (1)
  125. and
  126. .IR tail (1), 
  127. and is much faster than 
  128. .I sed(1)
  129. for long files.
  130. .PP
  131. The following options are recognized.
  132. .TP
  133. .B \-v
  134. All lines but those matching are printed.
  135. .TP
  136. .B \-c
  137. Only a count of matching lines is printed.
  138. .TP
  139. .B \-l
  140. The names of files with matching lines are listed (once) separated by newlines.
  141. .TP
  142. .B \-i
  143. Upper case is folded to lower case for comparisons.
  144. .TP
  145. .B \-n
  146. Each line is preceded by its relative line number from the end of the file.
  147. .TP
  148. .B \-b
  149. Each line is preceded by the block number on which it was found.
  150. This is sometimes useful in locating disk block numbers by context.
  151. .TP
  152. .B \-s
  153. Silent mode.  Nothing is printed (except error messages).
  154. This is useful for checking the error status.
  155. .TP
  156. .BI \-e " expression"
  157. Same as a simple
  158. .I expression 
  159. argument, but useful when the
  160. .I expression
  161. begins with a \-.
  162. .TP
  163. .B \-y
  164. Same as 
  165. .B \-i.
  166. .TP
  167. .B \-t
  168. Give a file tail whose first line matches the given pattern.
  169. There is no limit on the length of the tail.
  170. .TP
  171. .I \-cnt
  172. Give a file tail \fIcnt\fP lines long.
  173. This performs the same function as
  174. .IR tail (1)
  175. but is much less efficient for operations on pipes.  There is no
  176. limit on the length of the file tail (unlike 
  177. .I tail,
  178. which limits the total length of the file tail to 4096 characters).
  179. .LP
  180. In all cases the file name is shown if there is more than one input file.
  181. Care should be taken when using the characters $ * [ ^ | ( ) and \\ in the
  182. .I expression
  183. as they are also meaningful to the Shell.  It is safest to enclose the entire
  184. .I expression
  185. argument in single quotes \' \'.
  186. .LP
  187. In the following description of regular expression
  188. syntax, `character' excludes newline:
  189. .IP
  190. A \e followed by a single character other than newline matches that character.
  191. .IP
  192. The character ^ matches the beginning of a line.
  193. .IP
  194. The character $ matches the end of a line.
  195. .IP
  196. A 
  197. .B .
  198. (period) matches any character.
  199. .IP
  200. A single character not otherwise endowed with special
  201. meaning matches that character.
  202. .IP
  203. A string enclosed in brackets [\|] matches any single character from the string.
  204. Ranges of ASCII character codes may be abbreviated as in `a\-z0\-9'.
  205. A ]
  206. may occur only as the first character of the string.
  207. A literal \- must be placed where it can't be mistaken as a range indicator.
  208. .IP
  209. A regular expression followed by an * (asterisk) matches a sequence of 0
  210. or more matches of the regular expression.
  211. A regular expression followed by a + (plus) matches a sequence of 1 or more
  212. matches of the regular expression.
  213. A regular expression followed by a ? (question mark) matches a sequence of
  214. 0 or 1 matches of the regular expression.
  215. .IP
  216. Two regular expressions concatenated match a match of the first followed
  217. by a match of the second.
  218. .IP
  219. A regular expression enclosed in quoted parentheses
  220. matches a match for the regular expression (e.g. \e( \fIx\fP \e)).
  221. .IP
  222. A number \fIn\fP preceded by a backslash \e matches the same string
  223. as the \fIn\fPth
  224. regular expression enclosed in parentheses.
  225. .LP
  226. The order of precedence of operators at the same parenthesis level
  227. is [\|] then *+? then concatentation.
  228. .SH "SEE ALSO"
  229. ed(1),
  230. sed(1),
  231. sh(1),
  232. grep(1),
  233. bm(1),
  234. tail(1),
  235. body(1)
  236. .SH DIAGNOSTICS
  237. Exit status is 0 if any matches are found,
  238. 1 if none, 2 for syntax errors or inaccessible files.
  239. .SH BUGS
  240. Lines are limited to 2047 characters; longer lines are split into
  241. chunks at most 2047 characters long.
  242. .PP
  243. Data from non-seekable descriptors (pipes, sockets, and ttys)
  244. is copied to a temporary file, ``/tmp/rvg.*''.
  245. This file will not be removed if the
  246. program is killed with a SIGKILL or a SIGTERM.
  247. SHAR_EOF
  248. fi # end of overwriting check
  249. if test -f 'revgrep.c'
  250. then
  251.     echo shar: will not over-write existing file "'revgrep.c'"
  252. else
  253. cat << \SHAR_EOF > 'revgrep.c'
  254.  
  255. static char rcsid[] = " $Header: revgrep.c,v 1.4 86/02/24 09:10:37 nz Exp $";
  256.  
  257. /* **************************************************************
  258.  * revgrep: search files for a pattern backwards
  259.  *
  260.  *        revgrep is a variant of the grep(1) family, designed
  261.  *    to behave like grep, but do all line input in reverse.
  262.  *    (regular expression are matched left-to-right, as usual.)
  263.  *    the library routines re_comp and re_exec are the basis for
  264.  *    the regular-expression matching.
  265.  *
  266.  *    in addition to the functionality of grep, revgrep provides
  267.  *    the functionality of tail(1), but with the option to base
  268.  *    the length of the tail on a match of a regular expression
  269.  *    as well as on the line count.  further, revgrep does not
  270.  *    have tail's buffer-size limitations (at the price of being
  271.  *    a little slower).
  272.  *
  273.  *    the basic calling syntax for revgrep is as follows:
  274.  *
  275.  *            % revgrep [ options ] [ expression ] [ file ... ]
  276.  *
  277.  *    if no files are given, revgrep reads the std. input.
  278.  *    meaningful options are:
  279.  *
  280.  *           -v        print only lines that don't match
  281.  *           -c         print only a count of matching lines
  282.  *           -l         print only filenames of files with matches
  283.  *           -n         print relative line number with matches
  284.  *           -b        print block number in file with matches
  285.  *           -s         no output, only status
  286.  *           -h         don't print filenames with matches
  287.  *           -y         fold upper case to lower on input
  288.  *           -e         next argument is the expression
  289.  *
  290.  *           -t         text from first match (backwards) to
  291.  *                      end is printed in correct order.
  292.  *           -nnn       forego matches, do a -t on this many lines
  293.  */
  294.  
  295. #include <stdio.h>
  296. #include <ctype.h>
  297. #include <signal.h>
  298. #ifdef USG
  299. #include <sys/types.h>
  300. #include <string.h>
  301. #include <fcntl.h>
  302. #else
  303. #include <strings.h>
  304. #endif
  305. #include <sys/param.h>
  306. #include <sys/stat.h>
  307. #include <sys/file.h>
  308.  
  309. #ifdef USG
  310. #define RBUF 1024
  311. char *compiled_re, *regex();
  312. #else
  313. #define RBUF 2048
  314. #endif
  315.  
  316. #define NO_FILE_FLAG -10
  317.  
  318. int rev_fd = -1;
  319. int sty    =  0;
  320. int fflag  =  1;
  321. extern int errno;
  322. int exitval = 1;
  323. #ifdef USG
  324. #define Is_nonseek(FD,SB) \
  325.   ( (SB.st_mode == 0) || (SB.st_mode & S_IFMT == S_IFIFO) || (isatty(FD))  )
  326. #else
  327. #define Is_nonseek(FD,SB) \
  328.   ( (SB.st_mode == 0) || (SB.st_mode & S_IFMT == S_IFSOCK) || (isatty(FD)) )
  329. #endif USG
  330.  
  331.  
  332. char dont_match = 0;
  333. char print_count= 0;
  334. char print_names= (char) 4;
  335. char print_blocks=0;
  336. char print_lnum = 0;
  337. char print_matches= 1;
  338. char fold_upper = 0;
  339. char use_stdin  = 1;
  340. char do_tail    = 0;
  341. char silent_mode= 0;
  342. int  tail_cnt   = 0;
  343. char *tmp_name   = NULL;
  344.  
  345.  main(argc,argv)
  346.      int argc;
  347.      char *argv[];
  348. {
  349.     char *s1, *s2;
  350.     char *expr = NULL;
  351.     int i;
  352.     struct stat sb;
  353.  
  354.     /* first try to process options */
  355.     for(s1 = *++argv, argc--; argc > 0 && s1 != NULL; s1 = *++argv, argc--) {
  356.     if (*s1 != '-') break;
  357.     for(s2=s1; *++s2 != '\0'; ) {
  358.  
  359.         switch (*s2) {
  360.           case 'v':
  361.         dont_match++;
  362.         break;
  363.           case 'c':
  364.         print_count++;
  365.         print_matches=0;
  366.         break;
  367.           case 'n':
  368.         print_lnum = 1;
  369.         break;
  370.           case 'l':
  371.         print_names = 1;
  372.         print_matches=0;
  373.         break;
  374.           case 'b':
  375.         print_blocks++;
  376.         break;
  377.           case 's':
  378.         print_names = 0;
  379.         print_matches=0;
  380.         print_blocks = 0;
  381.         print_count = 0;
  382.         do_tail     = 0;
  383.         silent_mode = 1;
  384.         break;
  385.           case 'h':
  386.         print_names = 0;
  387.         break;
  388.           case 'i':
  389.           case 'y':
  390.         fold_upper = 1;
  391.         break;
  392.           case 't':
  393.         do_tail = 1;
  394.         print_matches = 0;
  395.         break;
  396.           case 'e':
  397.         expr = *++argv;
  398.         break;
  399.           default:
  400.         if ( isdigit(*s2) ) {
  401.             do_tail = 1;
  402.             print_matches = 0;
  403.             tail_cnt = atoi(s2);
  404.             for( ; *s2 != '\0' ; s2++);
  405.             s2--;
  406.         }
  407.         else {
  408.             if (silent_mode) exit(2);
  409.             fprintf(stderr,"revgrep: Unknown flag, '%c'.\n",*s2);
  410.             fprintf(stderr,
  411.                " usage: revgrep [ -slbchnyet# ] expr [ file ] ...\n");
  412.             exit(2);
  413.         }
  414.         }
  415.     }
  416.     }
  417.  
  418.     if (s1 != NULL && expr == NULL && tail_cnt == 0) {
  419.     expr = s1;
  420.     argv++; argc--;
  421.     }
  422.     if (expr == NULL && tail_cnt == 0) exit(2);
  423.     if (expr != NULL) {
  424. #ifdef USG
  425.     char *regcmp();
  426.     if ( (compiled_re = regcmp(expr,NULL)) == NULL) {
  427.         if ( ! silent_mode ) fprintf(stderr,"revgrep: bad expression.\n");
  428.         exit(2);
  429.     }
  430. #else
  431.     char *re_comp();
  432.     if ( (s1 = re_comp(expr)) != NULL) {
  433.         if ( ! silent_mode ) fprintf(stderr,"revgrep: %s \n",s1);
  434.         exit(2);
  435.     }
  436. #endif
  437.     }
  438.  
  439.     if (print_names > 1  &&
  440.     ( (*argv == NULL)?(1):(*(argv+1) == NULL))) print_names = 0;
  441.  
  442.     if (*argv == NULL) {
  443.     rev_fd = 0;
  444.     sty = 0;
  445.     if ( fstat(0,&sb) >= 0 ) {
  446.         if ( Is_nonseek(0,sb) )
  447.           {
  448.         if (  tmp_setup(0) < 0 ) {
  449.             if ( ! silent_mode ) perror("revgrep: tmp_setup");
  450.             exit(2);
  451.         }
  452.           }
  453.     }
  454.     else {
  455.         exit(2);
  456.     }
  457.     }
  458.     i = rgrep(argv);
  459.  
  460.     if ( tmp_name != NULL )
  461.       unlink(tmp_name);
  462.  
  463.     exit(i);
  464. }
  465.  
  466.  
  467. /* **************************************************************
  468.  * tail: print a tail, given a file position
  469.  *
  470.  *       This routine copies to stdout all the data after a
  471.  *   certain file position.  It checks various global flags
  472.  *   before starting the copy, and prints a message if
  473.  *   appropriate.  The file of which a tail is to be done
  474.  *   is assumed to be open on rev_fd.
  475.  */
  476.  tail(fpos,fname)
  477.      int fpos;
  478.      char *fname;
  479. {
  480.     int len;
  481.     char buf[RBUF];
  482.  
  483.     if (print_names) printf("%s:",fname);
  484.     if (print_blocks) printf("starting in %d",fpos/512);
  485.     if (print_names || print_blocks) putchar('\n');
  486.  
  487.     if (lseek(rev_fd,(fpos==0)?(0):(fpos+1),0) < 0) {
  488.     perror("revgrep: tail");
  489.     return(-1);
  490.     }
  491.     while( (len=read(rev_fd,buf,RBUF)) > 0)
  492.     fwrite(buf,sizeof(char),len,stdout);
  493.  
  494.     return(0);
  495. }
  496.  
  497.  
  498.  
  499. /* **************************************************************
  500.  * rgrep: backwards grep a set of files, or stdin
  501.  *
  502.  *      Rgrep performs a backwards grep on an input vector
  503.  *   of files.  If the input vector is Null, then the stdin
  504.  *   is assumed to be the input file.
  505.  *   This routine uses rline() to get the next line backwards,
  506.  *   and uses doline() to do pattern-matching and output on
  507.  *   the line received.
  508.  */
  509.  rgrep(files)
  510.      char *files[];
  511. {
  512.     char *s1, *s2;
  513.     char *lbuf;
  514.     int  pos, lcnt, match, match_cnt;
  515.     char didone = 0;
  516.  
  517.     for(didone = 0;
  518.     didone == 0 || *files != NULL;
  519.     files += ((*files==NULL)?0:1))
  520.     {
  521.     char *f, *rline();
  522.     f = *files;
  523.     for(lcnt=0, match_cnt=0, didone = 1;
  524.         ( lbuf = rline(&pos,f) ) != NULL;
  525.         f=NULL, lcnt++)
  526.       {
  527.           if (match = doline(lbuf,pos,lcnt,*files)) {
  528.           match_cnt++;
  529.           exitval=0;
  530.           if (do_tail) {
  531.               tail(pos,*files);
  532.               didone = 1;
  533.               break;
  534.           }
  535.           if (print_names && print_matches == 0 && print_count == 0) {
  536.               printf("%s\n",*files);
  537.               break;
  538.           }
  539.           }
  540.       }
  541.     if (print_count) {
  542.         if (print_names) printf("%s:%d\n",*files,match_cnt);
  543.         else printf("%d\n",match_cnt);
  544.     }
  545.     }
  546.     return(exitval);
  547. }
  548.  
  549. /* **************************************************************
  550.  * doline: match and handle a single line of input
  551.  *
  552.  *       This line receives a single text line, and performs
  553.  *    pattern matches on it if necessary.  Depending on the
  554.  *    various options, the line may be output with a message
  555.  *    two.
  556.  *       When a match of any kind occurs, 1 is returned.
  557.  *    Otherwise 0 is returned.
  558.  */
  559.  doline(lbuf,pos,lin,fname)
  560.      char *lbuf;
  561.      int pos, lin;
  562.      char *fname;
  563. {
  564.     register char *s1, *s2;
  565.     int i,j,m;
  566.  
  567.     if (tail_cnt > 0) {
  568.         if (lin >= tail_cnt || pos <= 1) return(1);
  569.         else return(0);
  570.     }
  571.  
  572.     if (fold_upper) {
  573.         char cmpbuf[RBUF*2];
  574.         for(s1=lbuf, s2=cmpbuf;
  575.         *s1 != '\0' && (s2-cmpbuf) < (RBUF*2); s1++, s2++ )
  576.           *s2 = (isupper(*s1))?(tolower(*s1)):(*s1);
  577.         *s2 = '\0';
  578.         s1 = cmpbuf;
  579.     }
  580.     else  s1 = lbuf;
  581.  
  582. #ifdef USG
  583.     m = (regex(compiled_re,s1)==NULL)?(0):(1);
  584. #else
  585.     m = re_exec(s1);
  586. #endif
  587.  
  588.     m = (dont_match)?(! m):(m);
  589.     if (! m) return(0);
  590.  
  591.     if (print_matches) {
  592.     if (print_names) printf("%s:",fname);
  593.     if (print_lnum) printf("-%d:",lin);
  594.     if (print_blocks) printf("%d:",pos/512);
  595.     printf("%s\n",lbuf);
  596.     }
  597.     return(1);
  598. }
  599.  
  600.  
  601. /* **************************************************************
  602.  * tmp_setup: read a non-seekable channel into a temp file
  603.  *
  604.  *       This routine reads the contents of a file descriptor
  605.  *  into a temporary file, and then passes back the name of the
  606.  *  file in a NULL-terminated vector.
  607.  *
  608.  *       A signal catcher is set up to delete the file if
  609.  *  the user hits ^C or ^\
  610.  */
  611.  tmp_setup(ifd)
  612.      int ifd;
  613. {
  614.     static char nambuf[60];
  615.     int ofd, len;
  616.     int sig_exit();
  617.     char dbuf[RBUF];
  618.  
  619.     sprintf(nambuf,"/tmp/rvg.a%d",getpid());
  620.     if ( (ofd = open(nambuf,O_RDWR | O_CREAT,0600)) < 0) return(-1);
  621.  
  622.     if ( signal(SIGINT,sig_exit) == SIG_IGN) signal(SIGINT,SIG_IGN);
  623.     if ( signal(SIGQUIT,sig_exit) == SIG_IGN) signal(SIGQUIT,SIG_IGN);
  624.     if ( signal(SIGHUP,sig_exit) == SIG_IGN) signal(SIGHUP,SIG_IGN);
  625.  
  626.     for( ; (len = read(ifd,dbuf,RBUF)) > 0; write(ofd,dbuf,len));
  627.     tmp_name = nambuf;
  628.     rev_fd = ofd;
  629.     return (ofd);
  630. }
  631.  
  632. sig_exit()
  633. {
  634.     close(0); close(1); close(2); close(3); close(4); close(5); close(6);
  635.     close(rev_fd);
  636.     if (tmp_name != NULL) unlink(tmp_name);
  637.     exit(2);
  638. }
  639.  
  640.  
  641.  
  642. /* **************************************************************
  643.  * rline: get next line going backwards, return pertinent info
  644.  *
  645.  *        This routine returns the next line going backwards from
  646.  *   the end of a file.  It also will open a new file, if
  647.  *   neccesary, and if given a file name as a parameter.
  648.  *
  649.  *   The line is written into a static buffer, and a pointer to
  650.  *   that small buffer is returned.  Also, the position in the
  651.  *   file of the start of the line is returned.
  652.  */
  653.  char *rline(posp, fname)
  654.      int *posp;
  655.      char *fname;
  656. {
  657.     register char  *s1, *s2;
  658.     static char *bufp;
  659.     static char bf[RBUF];
  660.     static char lbf[RBUF * 2], rlbf[RBUF * 2];
  661.     static int  bf_len, fpos;
  662.  
  663.     if (fname != NULL || fflag) {
  664.         if ( (bf_len = rblock(&fpos, bf, fname)) < 0) return(NULL);
  665.         bufp = bf + (bf_len - 1);
  666.         fflag = 0;
  667.     }
  668.  
  669.     /* by now we have a block, so search backwards for newline */
  670.     for(s1=lbf, s2=s1 + (2*RBUF - 1), *s2-- = '\0';
  671.         *bufp != '\n' &&   s2 >= s1;
  672.         bufp--, fpos--)
  673.       {
  674.         *s2-- = *bufp;
  675.         if (bufp == bf) {
  676.             if ((bf_len = rblock(&fpos,bf,NULL)) < 0) {
  677.                 fflag = 1;
  678.                 if (bf_len == NO_FILE_FLAG)
  679.                   return(NULL);
  680.                 break;
  681.             }
  682.             bufp = bf + bf_len;
  683.             fpos++;
  684.         }
  685.     }
  686.     fpos--;
  687.     if ( --bufp < bf ) fflag = 1;
  688.     *posp = fpos;
  689.  
  690.     return(++s2);
  691. }
  692.  
  693. /* **************************************************************
  694.  * rblock: return next block going backward in a file
  695.  *
  696.  *       This routine reads the next-last block in a file,
  697.  *    or starts a new file, given a name.
  698.  *    The flag  sty  tells whether the current file descriptor
  699.  *    has been stat-ed yet.  If not, it is implicit that the
  700.  *    blocks will be taken from the end of the file.
  701.  *
  702.  *       Note, if this routine fails with errors 29 or 5 then
  703.  *    a message is printed and the whole program aborts.
  704.  *
  705.  *      The length of the block read-and-returned is returned.
  706.  */
  707.  rblock(fposp, buf, fname)
  708.      int *fposp;
  709.      char *buf, *fname;
  710. {
  711.     static int nbp;
  712.     int    len;
  713.  
  714.     if (fname != NULL) {
  715.         if ( rev_fd > -1 ) close(rev_fd);
  716.         if ( (rev_fd=open(fname,O_RDONLY,0)) < 0) {
  717.             fprintf(stderr,"revgrep: ");
  718.             perror(fname);
  719.             return(NO_FILE_FLAG);
  720.         }
  721.         sty = 0;
  722.     }
  723.  
  724.     if (! sty) {
  725.         struct stat sb;
  726.         if (fstat(rev_fd, &sb) < 0) return(-1);
  727.         nbp = (sb.st_size  / RBUF ) * RBUF;
  728.         sty = 1;
  729.     }
  730.  
  731.     if (nbp < 0) return(-1);
  732.     if ( lseek(rev_fd,nbp,0) < 0) {
  733.         if (errno == 29  ||  errno == 5) {
  734.             perror("revgrep: rblock");
  735.             exit(1);
  736.         }
  737.         else return(-1);
  738.     }
  739.  
  740.     if ( (len = read(rev_fd,buf,RBUF)) < 0) return(-1);
  741.     *fposp = nbp + len;
  742.     nbp = nbp - RBUF;
  743.     return( len );
  744. }
  745. SHAR_EOF
  746. fi # end of overwriting check
  747. #    End of shell archive
  748. exit 0
  749.  
  750. ------------
  751. -- 
  752. ...nz@wucs (ECL - we're here to provide superior computing)
  753.  
  754.     "We can fit an infinite number of wires into this ... junction box,
  755.         ... but we don't do that far in practice"
  756.  
  757.  
  758. % ine */
  759.     f